package thread;


class SingletonLazy2 {
    private static SingletonLazy2 singletonLazy2 = null;
    private static Object locker = new Object();

    public static SingletonLazy2 getSingletonLazy2() {
        if(singletonLazy2 == null) {
            synchronized (locker) {
                if(singletonLazy2 == null) {
                    singletonLazy2 = new SingletonLazy2();
                }
            }
        }
        return singletonLazy2;
    }

    private SingletonLazy2() {

    }
}
//上面的代码还是有点问题的，上面的代码存在一点问题 比如：可能出现 内存可见性问题，但最可能出现的是指令重排序的问题
//我们来看看如何解决这个问题：
class SingletonLazy3 {
    private static volatile SingletonLazy3 singletonLazy3 = null;
    private static Object locker = new Object();

    public static SingletonLazy3 getSingletonLazy3() {
        if(singletonLazy3 == null) {
            synchronized (locker) {
                if (singletonLazy3 == null) {
                    singletonLazy3 = new SingletonLazy3();
                }
            }
        }
        return singletonLazy3;
    }

    private SingletonLazy3() {

    }
}
public class Demo21 {
    //对于我们的单例模式呢，饿汉模式是在多线程的情况下是安全的，而懒汉模式是不安全的
    //那么我们如何才能解决这个问题呢？
    public static void main(String[] args) {

    }
}
